package bachelor.view {
	import CustomEvent.CustomEvent;

	import app.core.action.RotatableScalable;

	import bachelor.Globals;

	import fiducialTuioAS3.CountryFiducialHandler;
	import fiducialTuioAS3.KeywordFiducialHandler;
	import fiducialTuioAS3.WritingFiducialHandler;
	import fiducialTuioAS3.tuio.PropObject;
	import fiducialTuioAS3.tuio.TUIOManager;
	import fiducialTuioAS3.tuio.TouchEvent;

	import gs.TweenLite;
	import gs.easing.Cubic;
	import gs.easing.Strong;

	import flash.display.MovieClip;
	import flash.events.Event;

	/**
	 * @author Johannes
	 */
	public class GUI extends MovieClip 
	{
		
		/** MC-VERSCHACHTELUNG
		 *  ============================================================================
		 *    
		 *    MAIN
		 *       GUI
		 *         → _keywordPanel
		 *         → _countryHelper
		 *         → _screensaver
		 *         → _countryFeedbackContainer
		 *               → CountryFeedback 1
		 *               → CountryFeedback 2
		 *               → CountryFeedback 3
		 *               → ...
		 *               → KeywordFeedback 1
		 *               → KeywordFeedback 2
		 *               → KeywordFeedback 3
		 *               → ...
		 *         → _countryInterfaceContainer
		 *               → CountryInterface 1
		 *               → CountryInterface 2
		 *               → CountryInterface 3
		 *               → ...
		 *         → _bg
		 *         → countryFiducialHandler 1
		 *         → countryFiducialHandler 2
		 *         → countryFiducialHandler 3
		 *         → ...
		 *         → keywordFiducialHandler 1
		 *         → keywordFiducialHandler 2
		 *         → keywordFiducialHandler 3
		 *         → ...
		 *         → _TuioManager
		 *  
		 *  ============================================================================
		 */

////////////////////////////////////////////////////////////////////////////////
/////// VARIABLES //////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

		// Fiducials
		private var _tuioManager : TUIOManager;
		
		// MCs
		private var _raster 							: MovieClip = MovieClip(new rasterMC());
		private var _bgVerlauf 							: MovieClip	= MovieClip(new bgMC());
		private var _activeCountryPanelContainer  		: MovieClip = new MovieClip();
		private var _dock 								: Dock 		= new Dock();
		private var _activeCountryFeedbackContainer		: MovieClip = new MovieClip();
		private var _activeKeywordFeedbackContainer  	: MovieClip = new MovieClip();
		private var _writingMC 							: MovieClip = new MovieClip();

		// Arrays zur Verwaltung
		private var _activeCountryFeedbackArray 	: Array = [];
		private var _activeCountryPanelArray 		: Array = [];
		private var _activeKeywordFeedbackArray 	: Array = [];
		
		// Größenwerte
		private var _hitAreaQuadrat 	: int = 85;
		
		// Zustände
		private var _dockState 	 		: String = "";
		private var _activeKeywordID 	: int = -1; 	// -1 := INAKTIV
		
		// Events
		public static const COUNTRY_FIDUCIAL_MOVED : String = "countryFiducialMoved";
		public static const COUNTRY_FIDUCIAL_ADDED : String = "countryFiducialAdded";

		// Bookmarks
		private var _bookmarkArray : Array = [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]];
		private var _bookmarkContainer : MovieClip = new MovieClip();
		
		
		
////////////////////////////////////////////////////////////////////////////////
/////// CONSTRUCTOR ////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
		public function GUI() 
		{
//			trace("GUI -> Constructor init...");
			init();
		}
		
		
////////////////////////////////////////////////////////////////////////////////
/////// METHODS ////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/////// INIT ///////////////////////////////////////////////////////////////////
		private function init() : void
		{
//			trace("GUI -> init() ...");

			
            //--------init TUIO-Manager ----------------------------------------
            _tuioManager = new TUIOManager(this);
			this.addChild(_tuioManager);


            //--------init Country-Trackers ------------------------------------
			for(var i:int = 12;i <= 20; i++) 
			{
				var countryPropObject : PropObject = _tuioManager.getProp(i);
				var countryFiducialHandler : CountryFiducialHandler = new CountryFiducialHandler(i);
				addChild(countryFiducialHandler);
				countryPropObject.addTUIOPropEventListeners(countryFiducialHandler);
				countryFiducialHandler.addEventListener(CountryFiducialHandler.COUNTRY_FIDUCIAL_ADDED, countryFiducialAddedHandler);
				countryFiducialHandler.addEventListener(CountryFiducialHandler.COUNTRY_FIDUCIAL_REMOVED, countryFiducialRemovedHandler);
				countryFiducialHandler.addEventListener(CountryFiducialHandler.COUNTRY_FIDUCIAL_MOVED, countryFiducialMovedHandler);
				countryFiducialHandler.addEventListener(CountryFiducialHandler.COUNTRY_FIDUCIAL_ROTATED, countryFiducialRotatedHandler);
			}
			
            //--------init Keyword-Trackers ------------------------------------
			for(var j:int = 1; j <= 8; j++) 
			{
				var keywordPropObject : PropObject = _tuioManager.getProp(j);
				var keywordFiducialHandler : KeywordFiducialHandler= new KeywordFiducialHandler(j);
				addChild(keywordFiducialHandler);
				keywordPropObject.addTUIOPropEventListeners(keywordFiducialHandler);
				keywordFiducialHandler.addEventListener(KeywordFiducialHandler.KEYWORD_ADDED, keywordFiducialAddedHandler);
				keywordFiducialHandler.addEventListener(KeywordFiducialHandler.KEYWORD_REMOVED, keywordFiducialRemovedHandler);
				keywordFiducialHandler.addEventListener(KeywordFiducialHandler.KEYWORD_MOVED, keywordFiducialMovedHandler);
				keywordFiducialHandler.addEventListener(KeywordFiducialHandler.KEYWORD_ROTATED, keywordFiducialRotatedHander);
			}
			var writingPropObject : PropObject = _tuioManager.getProp(9);
			var writingFiducialHandler : WritingFiducialHandler = new WritingFiducialHandler(9);
			addChild(writingFiducialHandler);
			writingPropObject.addTUIOPropEventListeners(writingFiducialHandler);
			writingFiducialHandler.addEventListener(WritingFiducialHandler.WRITING_FIDUCIAL_ADDED, writingFiducialAddedHandler);
			writingFiducialHandler.addEventListener(WritingFiducialHandler.WRITING_FIDUCIAL_REMOVED, writingFiducialRemovedHandler);
			writingFiducialHandler.addEventListener(WritingFiducialHandler.WRITING_FIDUCIAL_MOVED, writingFiducialMovedHandler);
//			keywordFiducialHandler.addEventListener(WritingFiducialHandler.WRITING_FIDUCIAL_ROTATED, writingFiducialRotatedHander);

            //--------init Background ------------------------------------------
			_raster.x = 512;
			_raster.y = 384;
			_raster.alpha = 0.1;
			addChild(_raster);
			addChild(_bgVerlauf);



            //--------init Containers & Dock (Reihenfolge) ---------------------
			addChild(_bookmarkContainer);
			addChild(_activeCountryPanelContainer);
            addChild(_dock);
            
            _writingMC.graphics.beginFill(0x00FF00, 0);
            _writingMC.graphics.drawRect(-70, -40, 140, 80);
            _writingMC.graphics.endFill();
            addChild(_writingMC);
            _writingMC.visible = false;
			
			addChild(_activeCountryFeedbackContainer);
			addChild(_activeKeywordFeedbackContainer);

		}

		
	
		
		
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// COUNTRY ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	

/////// COUNTRY ADDED //////////////////////////////////////////////////////////
		private function countryFiducialAddedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> createCountry(no" + evt.data.f_id + ") init...");
			
			dispatchEvent(new CustomEvent(COUNTRY_FIDUCIAL_ADDED, [evt.data.xpos, evt.data.ypos]));
			TweenLite.to(_bgVerlauf, 20, {x: evt.data.ypos, y: evt.data.xpos, ease: Cubic.easeOut, overwrite: 2});
			
			var freeColorIndex : uint = getFreeColorIndex(); 
			/*
			 * Neues Feedback erstellen;
			 * Counrties werden erst bei keywordActivated erzeugt
			 */
			var countryFeedbackToAdd : CountryFeedback = new CountryFeedback(evt.data.f_id, evt.data.rotation, freeColorIndex);
			countryFeedbackToAdd.x = evt.data.xpos;
			countryFeedbackToAdd.y = evt.data.ypos;
			countryFeedbackToAdd.rotation = evt.data.rotation;
			_activeCountryFeedbackContainer.addChild(countryFeedbackToAdd);
			/*
			 * Erstelltes CountryFeedback im Array _activeCountryFeedbackArray an entsprechende Stelle speichern
			 */		
			_activeCountryFeedbackArray[evt.data.f_id] = countryFeedbackToAdd;
			
			
			/*
			 * Es liegt bereits ein Keyword, deshalb sofort das Country erstellen
			 */
			if(_activeKeywordID > -1 && _activeKeywordID != 9) 
			{
				var countryPanelToAdd : CountryPanel = new CountryPanel(evt.data.f_id, evt.data.rotation, freeColorIndex, _activeKeywordID);
				countryPanelToAdd.x = evt.data.xpos;
				countryPanelToAdd.y = evt.data.xpos;
				countryPanelToAdd.rotation = evt.data.rotation;
				_activeCountryPanelContainer.addChild(countryPanelToAdd);
				countryPanelToAdd.addEventListener(CountryPanel.LAYERS_ADDED, onLayersAddedHandler);
				countryPanelToAdd.addEventListener(CountryPanel.CREATE_BOOKMARK, createBookmarkHandler);
				countryPanelToAdd.addEventListener(CountryPanel.GRID_CHANGED, gridChangedHandler);
				
				/*
				 * Erstelltes CountryPanel im Array _activeCountryPanelArray an entsprechende Stelle speichern
				 */
				_activeCountryPanelArray[evt.data.f_id] = countryPanelToAdd;
			}
			/*
			 * Aktuellen TableState checken
			 */
			setDockState(); 
			
		}
		

/////// COUNTRY MOVED oEF ////////////////////////////////////////////////////// 
		private function countryFiducialMovedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> countryFiducialMovedHandler() ...");
			
			dispatchEvent(new CustomEvent(COUNTRY_FIDUCIAL_MOVED, [evt.data.xpos, evt.data.ypos]));
			TweenLite.to(_bgVerlauf, 15, {x: evt.data.xpos-40, y: evt.data.ypos-40, ease: Cubic.easeOut, overwrite: 2});
			TweenLite.to(_activeCountryFeedbackArray[evt.data.f_id] as CountryFeedback, Globals.fadeTime, {x: evt.data.xpos, y: evt.data.ypos, ease: Cubic.easeOut, overwrite: 2});
			
			/*
			 * Ist ein Keyword aktiviert, muss auch das CountryPanel entfernt werden
			 */
			if(_activeCountryPanelArray[evt.data.f_id] is CountryPanel)
			{
				TweenLite.to(_activeCountryPanelArray[evt.data.f_id] as CountryPanel, Globals.fadeTime, {x: evt.data.xpos, y: evt.data.ypos, ease: Cubic.easeOut, overwrite: 2});
			}		
		
		}


/////// COUNTRY ROTATED (oEF) //////////////////////////////////////////////////
		private function countryFiducialRotatedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> rotateScala() ...");
			/*
			 * Checken, ob Scala sich drehen muss
			 */
//			var countryFeedbackToRotate : CountryFeedback = _activeCountryFeedbackArray[evt.data.f_id] as CountryFeedback;
			if(_activeCountryFeedbackArray[evt.data.f_id] is CountryFeedback)
			{
				_activeCountryFeedbackArray[evt.data.f_id].setScalaRotation(evt);
			} 	
			
		}
		
		
	
/////// COUNTRY REMOVED ////////////////////////////////////////////////////////
		private function countryFiducialRemovedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> countryFiducialRemovedHandler() ... mit der ID " + evt.data.f_id);
			if(_activeCountryFeedbackArray[evt.data.f_id] is CountryFeedback)
			{
			
				var countryFeedbackToRemove : CountryFeedback = _activeCountryFeedbackArray[evt.data.f_id] as CountryFeedback;
				/*
				 * Farb-Index im Array wieder freigeben für nächstes Land
				 */
				var tintColorIndex : int = countryFeedbackToRemove.getTintColorIndex();
				setFreeColorIndex(tintColorIndex);
				
				_activeCountryFeedbackContainer.removeChild(countryFeedbackToRemove);
				_activeCountryFeedbackArray[countryFeedbackToRemove.getID()] = [];
			}
			
						
			/*
			 * Falls Keyword aktiv, ist Country vorhanden.
			 * Dieses jetzt ausblenden und dann löschen.
			 */
			if(_activeCountryPanelArray[evt.data.f_id] is CountryPanel)
			{
				// CountryPanel entfernen
				var countryPanelToRemove  : CountryPanel  = _activeCountryPanelArray[evt.data.f_id] as CountryPanel;
				_activeCountryPanelContainer.removeChild(countryPanelToRemove);
				_activeCountryPanelArray[countryPanelToRemove.getID()] = [];
				
				// Bookmarks entfernen
				for(var j:int = 0; j < _bookmarkArray[evt.data.f_id].length; j++)
				{
					if(_bookmarkArray[evt.data.f_id][j] is Bookmark)
					{
						var bookmarkToFadeOut : Bookmark = _bookmarkArray[evt.data.f_id][j] as Bookmark;
						bookmarkStartFadingOut(bookmarkToFadeOut);
					}
				}
				
			}
			
			
			/*
			 * Aktuellen TableState checken
			 */
			setDockState();
		}
		

		
		
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// KEYWORDS ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/////// KeywordFiducial gelegt /////////////////////////////////////////////////
		private function keywordFiducialAddedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> keywordFiducialAddedHandler() ... FiducialID " + evt.data.f_id);
			//Die Aktivierung des Countries erfolgt erst bei onMove
			
			/*
			 * Neues Keyword erstellen
			 */
			var keywordFeedbackToadd : KeywordFeeback = new KeywordFeeback();
			keywordFeedbackToadd.x = evt.data.xpos;
			keywordFeedbackToadd.y = evt.data.ypos;
			keywordFeedbackToadd.rotation = evt.data.rotation;
			_activeKeywordFeedbackContainer.addChild(keywordFeedbackToadd);
			/*
			 * Erstelltes Keyword im Array _activeKeywordFeedbackArray an entsprechende Stelle speichern
			 */
			_activeKeywordFeedbackArray[evt.data.f_id] = keywordFeedbackToadd;
			/*
			 * Wurde das Keyword direkt auf das Dock aufgelegt und somit aktiviert?
			 */
			if(keywordHitsDock(keywordFeedbackToadd) == true) 
			{
				/*
				 * Aktives Keyword für später aufgelegte Countries zwischenspeichern
				 */
				_activeKeywordID = evt.data.f_id;
				/*
				 * Alle CountryPanels sollen erstellt werden
				 */
				startInitializingAllCountryPanels(evt.data.f_id);
				/*
				 * Aktuellen TableState checken
				 */
				setDockState();
			}
		}




/////// KeywordFiducial bewegt /////////////////////////////////////////////////
		private function keywordFiducialMovedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> keywordFiducialMovedHandler() ... FiducialID " + evt.data.f_id);
			TweenLite.to(_activeKeywordFeedbackArray[evt.data.f_id], Globals.fadeTime, {x: evt.data.xpos, y: evt.data.ypos, ease: Cubic.easeOut, overwrite: 2});		
			
			// Hittest: Trifft Keyword das Keyword-Dock?
			if(keywordHitsDock(_activeKeywordFeedbackArray[evt.data.f_id]) == true) 
			{
				// Keyword war inaktiv & Dock jetzt erstmalig getroffen -> Keyword aktivieren
				if((_activeKeywordID <= -1)) 																		// && (_activeKeywordID != evt.data.f_id) 
				{
					/*
					 * Aktives Keyword für später aufgelegte Countries zwischenspeichern
					 */
					_activeKeywordID = evt.data.f_id;
					/*
					 * Alle CountryPanels sollen erstellt werden
					 */
					startInitializingAllCountryPanels(evt.data.f_id);
					/*
					 * Aktuellen TableState checken
					 */
					setDockState();
				}
			} else
			{
				// Keyword war aktiv & Dock nicht mehr getroffen -> Keyword deaktivieren
				if((_activeKeywordID > -1) && (_activeKeywordID == evt.data.f_id)) 
				{
					/*
					 * Aktives Keyword löschen
					 */
					_activeKeywordID = -1;
					/*
					 * Alle CountryPanels sollen sich ausblenden
					 */
					startDeinitializingAllCountryPanels();
					/*
					 * Aktuellen TableState checken
					 */
					setDockState();
				}
			}
			
		}

		
		
/////// KeywordFiducial gedreht ////////////////////////////////////////////////
		private function keywordFiducialRotatedHander(evt : CustomEvent) : void
		{
//			trace("GUI -> keywordFiducialRotatedHander() ... FiducialID " + evt.data.f_id);
			_activeKeywordFeedbackArray[evt.data.f_id].rotation = evt.data.rotation;
		}

		
		
		
/////// KeywordFiducial entfernt ///////////////////////////////////////////////
		private function keywordFiducialRemovedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> keywordFoducialRemovedHandler() ... FiducialID " + evt.data.f_id);
			var removedKeyword : KeywordFeeback = _activeKeywordFeedbackArray[evt.data.f_id] as KeywordFeeback;
			_activeKeywordFeedbackArray[evt.data.f_id] = [];
			_activeKeywordFeedbackContainer.removeChild(removedKeyword);
			/*
			 * Traf das entfernte Keyword das Dock und war somit aktiv?
			 */
			if(keywordHitsDock(removedKeyword) == true) 
			{
				/*
				 * Aktives Keyword löschen
				 */
				_activeKeywordID = -1;
				/*
				 *  Alle CountryPanels sollen sich ausblenden
				 */
				startDeinitializingAllCountryPanels();
				/*
				 * Aktuellen TableState checken
				 */
				setDockState();
				
			}
		}
		




////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// WRITING ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////		
		private function writingFiducialAddedHandler(evt : CustomEvent) : void 
		{
//			trace("GUI -> WRITING-FiducialAddedHandler() ...");
			_writingMC.visible = true;
		}	

		private function writingFiducialRemovedHandler(evt : CustomEvent) : void 
		{
//			trace("GUI -> WRITING-FiducialRemovedHandler() ...");
			_writingMC.visible = false;
		}	

		private function writingFiducialMovedHandler(evt : CustomEvent) : void
		{
//			trace("GUI -> WRITING-FiducialMovedHandler() ...");
			TweenLite.to(_writingMC, Globals.fadeTime, {x: evt.data.xpos, y: evt.data.ypos, ease: Cubic.easeOut, overwrite: 2});		
			
			// Hittest: Trifft Keyword das Keyword-Dock?
			if(writingHitsDock() == true) 
			{
				// Keyword war inaktiv & Dock jetzt erstmalig getroffen -> Keyword aktivieren
//				trace("WRITING getroffen");
				if((_activeKeywordID <= -1)) 																		 
				{
					_activeKeywordID = evt.data.f_id;
//					trace("neue Keyword-ID: " + _activeKeywordID);
					setDockState();
				}
			} else
			{
				// Keyword war aktiv & Dock nicht mehr getroffen -> Keyword deaktivieren
				/*
				 * Aktives Keyword löschen
				 */
//				trace("WRITING nicht getroffen");
				_activeKeywordID = -1;
				setDockState();
			}
		}
			
		
		
		
		
		
		
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// KEYWORD AKTIVIERT //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		private function startInitializingAllCountryPanels(p_activeKeywordID : int) : void 
		{
//			trace("GUI -> setActiveKeyword() ...");
//			trace("===========================\nKEYWORD AKTIV: " + Globals.keywordArray[p_activeKeywordID][1] + "\n============================");
			/*
			 * Für alle gelegten CountryFiducials ein Country erzeugen: Layers jetzt laden
			 * Panel / Scala wird später bei vollzogenem Ladevorgang initialisiert 
			 */
			for(var i:int = 0; i < _activeCountryFeedbackArray.length; i++) 
			{
				if(_activeCountryFeedbackArray[i] is CountryFeedback) 
				{
					var countryFeedbackToActivate : CountryFeedback = _activeCountryFeedbackArray[i] as CountryFeedback;
					/*
					 * Neues CountryPanel erstellen anhand des AKTUELLEN 
					 * CountryFeedback-Aussehens (Farbe, Rotation, Position)
					 */
					var countryPanelToAdd : CountryPanel = new CountryPanel(i, countryFeedbackToActivate.rotation, countryFeedbackToActivate.getTintColorIndex(), _activeKeywordID);
					countryPanelToAdd.x = countryFeedbackToActivate.x;
					countryPanelToAdd.y = countryFeedbackToActivate.y;
					countryPanelToAdd.rotation = countryFeedbackToActivate.rotation;
					_activeCountryPanelContainer.addChild(countryPanelToAdd);
					countryPanelToAdd.addEventListener(CountryPanel.LAYERS_ADDED, onLayersAddedHandler);
					countryPanelToAdd.addEventListener(CountryPanel.CREATE_BOOKMARK, createBookmarkHandler);
					countryPanelToAdd.addEventListener(CountryPanel.GRID_CHANGED, gridChangedHandler);
					/*
					 * Erstelltes Land im Array _activeCountryPanelArray an entsprechende Stelle speichern
					 */
					_activeCountryPanelArray[countryFeedbackToActivate.getID()] = countryPanelToAdd;
//					trace("GUI-> startInitializingAllCountryPanels() ::: Panel ist jetzt im Array");
					
					
					
				}
			}
			
		}

/////// Alle CountryPanels removen /////////////////////////////////////////////
		private function startDeinitializingAllCountryPanels() : void
		{
//			trace("GUI -> keywordDeactivated() ...");
//			trace("ENTFERNE LÄNDER. LAND 0: " + _activeCountryPanelArray[0]);
			/*
			 * Alle gelegten Countries ggf. ausblenden und dann löschen
			 */
			for(var i:int = 0; i < _activeCountryPanelArray.length; i++) 
			{
				if(_activeCountryPanelArray[i] is CountryPanel) 
				{
					
					// CountryPanel entfernen
					var countryPanelToRemove : CountryPanel = _activeCountryPanelArray[i] as CountryPanel;
					if(countryPanelToRemove.getLoadingState() == true) 
					{
						/*
						 * Wenn Country noch lädt: 
						 * Country einfach entfernen
						 */
//						trace("GUI -> keywordDeactivated() ... Lösche CountryPanel SOFORT");
						_activeCountryPanelArray[countryPanelToRemove.getID()] = [];
						_activeCountryPanelContainer.removeChild(countryPanelToRemove);
					} else {
						/*
						 * Wenn Country fertig geladen: 
						 * Layers, Panel und Scala ausblenden, dann Country löschen
						 */
//						trace("GUI -> keywordDeactivated() ... Lösche CountryPanel NACH DEINIT (momentan noch SOFORT)");
						_activeCountryPanelArray[countryPanelToRemove.getID()] = [];
						_activeCountryPanelContainer.removeChild(countryPanelToRemove);
					}
					
					// Scala ausblenden
					var countryFeedbackHideScala : CountryFeedback = _activeCountryFeedbackArray[i] as CountryFeedback;
//					trace("GUI -> keywordDeaktivated() ... HIDE SCALA");
					countryFeedbackHideScala.hideScala();
					
					// Bookmarks entfernen
					for(var j:int = 0; j < _bookmarkArray[i].length; j++)
					{
						if(_bookmarkArray[i][j] is Bookmark)
						{
							var bookmarkToFadeOut : Bookmark = _bookmarkArray[i][j] as Bookmark;
							bookmarkStartFadingOut(bookmarkToFadeOut);
						}
					}
					
				}
			}
		}
		
		








////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// DOCK STATUS ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


		private function setDockState() : void
		{
//			trace("GUI -> setDockState() ... ");
			/** 
			 *  activeFiducials = ""  					->  Tisch inaktiv, beide   Hilfen anzeigen
			 *  activeFiducials = "country" 			->  Tisch inaktiv, Keyword-Hilfe  anzeigen
			 *  activeFiducials = "keyword" 			->  Tisch inaktiv, Country-Hilfe  anzeigen
			 *  activeFiducials = "country+keyword" 	->  Tisch   aktiv
			*/ 
			var newDockState : String = "";
			
			// Liegt ein Country-Fiducial?
			for(var i:int = 0; i < _activeCountryFeedbackArray.length; i++)
			{
				if(_activeCountryFeedbackArray[i] is CountryFeedback)
				{
					/*
					 * Country-Fiducial gefunden
					 */
					newDockState = "country";
					break;
				} 
			}
			
			// Ist Keyword aktiv?
			if(_activeKeywordID > -1 && _activeKeywordID != 9) 
			{
				// Keyword ist aktiv (nicht writing!)
				/*
				 * Keyword aktiv
				 */
				if(newDockState == "country")
				{
					newDockState = "country+keyword";
				} else 
				{
					newDockState = "keyword";
				}
			} else if(_activeKeywordID == 9) 
			{
				// Writing ist aktiv
				if(newDockState == "country")
				{
					newDockState = "country+writing";
				} else 
				{
					newDockState = "writing";
				}
			}
			
			// Wenn NEUER DockState
			if(_dockState != newDockState) 
			{
//				trace("GUI -> setDockState() ... Neuer Status: " + _dockState);
				_dock.changeDockState(newDockState);
				_dockState = newDockState;
			}

		}














////////////////////////////////////////////////////////////////////////////////
/////// EVENT-LISTENERS ////////////////////////////////////////////////////////
		
/////// Object deinitialized (vollständig ausgeblendet) ////////////////////////
		private function onObjectDeinitializedHandler(evt : Event) : void 
		{
//			trace("GUI -> onObjectDeinitializedHandler() ...");
			switch (evt.type)
			{
				case CountryPanel.COUNTRY_PANEL_DEINITIALIZED:
//					trace("================== COUNTRY_PANEL ist fertig AUSGEBLENDET: jetzt entfernen");
					var countryPanelToRemove : CountryPanel = evt.currentTarget as CountryPanel;
					countryPanelToRemove.removeEventListener(CountryPanel.COUNTRY_PANEL_DEINITIALIZED, onObjectDeinitializedHandler);
					countryFeedbackToRemove.removeEventListener(CountryFeedback.SCALA_VERLAUF_ROTATED, onScalaRotatedHandler);
					_activeCountryPanelArray[countryPanelToRemove.getID()] = [];
					_activeCountryPanelContainer.removeChild(countryPanelToRemove);
//					trace("ARRAY wurde gelert: " + _activeCountryPanelArray[countryPanelToRemove.getID()]);
					break;
					
				case CountryFeedback.COUNTRY_FEEDBACK_DEINITIALIZED:
//					trace("================== COUNTRY_FEEDBACK ist fertig AUSGEBLENDET: jetzt entfernen");
					var countryFeedbackToRemove : CountryFeedback = evt.currentTarget as CountryFeedback;
					countryFeedbackToRemove.removeEventListener(CountryFeedback.COUNTRY_FEEDBACK_DEINITIALIZED, onObjectDeinitializedHandler);
					countryFeedbackToRemove.removeEventListener(CountryFeedback.SCALA_VERLAUF_ROTATED, onScalaRotatedHandler);
					_activeCountryFeedbackArray[countryFeedbackToRemove.getID()] = [];
//					trace("ARRAY wurde gelert: " + _activeCountryFeedbackArray[countryFeedbackToRemove.getID()]);
					_activeCountryFeedbackContainer.removeChild(countryFeedbackToRemove);
					break;
				
			}
		}



/////// Grid changed ///////////////////////////////////////////////////////////
		private function gridChangedHandler(evt : CustomEvent) :  void
		{
//			trace("GUI -> gridChangedHandler() ::: Das CountryFeedback " + evt.data[0] + " muss in die Ansicht " + evt.data[1] + " wechseln");
			if(_activeCountryFeedbackArray[evt.data[0]] is CountryFeedback)
			{
				var countryFeedbackToChangeScala : CountryFeedback = _activeCountryFeedbackArray[evt.data[0]] as CountryFeedback;
				countryFeedbackToChangeScala.setNewGrid(evt.data[1]);
			}
		}



/////// Layers fertig geladen //////////////////////////////////////////////////
		private function onLayersAddedHandler(evt:Event) : void 
		{
//			trace("GUI -> onLayersAddedHandler() ...");
			var loadedCountryPanel : CountryPanel = evt.currentTarget as CountryPanel;
			loadedCountryPanel.removeEventListener(CountryPanel.LAYERS_ADDED, onLayersAddedHandler);
			
			// Ist CountryPanel wirklich noch im Array?
			if(_activeCountryPanelArray[loadedCountryPanel.getID()] is CountryPanel)
			{
				// Skala einblenden
				_activeCountryFeedbackArray[loadedCountryPanel.getID()].showScala();
				_activeCountryFeedbackArray[loadedCountryPanel.getID()].addEventListener(CountryFeedback.SCALA_VERLAUF_ROTATED, onScalaRotatedHandler);
			}
		}
		
		
/////// Skala wurde rotiert ////////////////////////////////////////////////////
		private function onScalaRotatedHandler(evt : CustomEvent) : void 
		{
//			var eventInfos : Array = evt.data as Array;
			var rotatedCountryFeedbackScala : CountryFeedback = evt.currentTarget as CountryFeedback;
			if(_activeCountryPanelArray[rotatedCountryFeedbackScala.getID()] is CountryPanel)
			{
				var associatedCountryPanel : CountryPanel = _activeCountryPanelArray[rotatedCountryFeedbackScala.getID()] as CountryPanel;
				// Layers bewegen
				associatedCountryPanel.moveLayers(evt.data[0] as int, evt.data[1] as String);
			}
		}
		

		
		
		
		
////////////////////////////////////////////////////////////////////////////////
/////// HELPERS ////////////////////////////////////////////////////////////////


/////// Trifft Keyword das Dock? ///////////////////////////////////////////////
		private function keywordHitsDock(p_keywordFeedback : *) : Boolean 
		{
			if(p_keywordFeedback.x > (512 - _hitAreaQuadrat/2) && p_keywordFeedback.x < (512 + _hitAreaQuadrat/2)  && p_keywordFeedback.y > (110 - _hitAreaQuadrat/2) && p_keywordFeedback.y < (110 + _hitAreaQuadrat/2)) 
			{
				return true;
			} else 
			{
				return false;
			}
		}
		private function writingHitsDock() : Boolean 
		{
//			trace("GUI -> writingHitsDock() ...");
			if(_activeKeywordID != 9)
			{
				// Writing ist inaktiv, darf nur oben mittig treffen
				if(_writingMC.x > (512 - _hitAreaQuadrat/2) && _writingMC.x < (512 + _hitAreaQuadrat/2)  && _writingMC.y > (110 - _hitAreaQuadrat/2) && _writingMC.y < (110 + _hitAreaQuadrat/2)) 
				{
					return true;
				} else 
				{
					return false;
				}
			} else if(_activeKeywordID == 9)
			{
				// Writing ist schon aktiviert, jetzt nach links schieben
				if(_writingMC.y > (110 - _hitAreaQuadrat/3) && _writingMC.y < (110 + _hitAreaQuadrat/3)) 
				{
					return true;
				} else 
				{
					return false;
				}
			}
			// Falls gar nichts
			return false;
		}





/////// Nächste freie Farbe ////////////////////////////////////////////////////
		private function getFreeColorIndex() : int 
		{
//			trace("GUI -> getNextFreeColor() ...");
			var nextFreeColorIndex : int = 0;
			/*
			 * Nächste freie Farbe aus dem Array suchen und zurückgeben.
			 * Diese Farbe als belegt speichern.
			 */
			for(var i:int = 0; i < 9999; i++) 
			{
				// Zufallszahl zwischen 1 und 9
				var rndPos : int = Math.round(Math.random() * (9 - 1)) + 1;
				// Ist die Zufallszahl noch frei?
//				trace("GUI -> getFreeColorIndex() ::: rnd = " + rndPos);
				if(Globals.countryColorArray[rndPos][0] == false) 
				{
					Globals.countryColorArray[rndPos][0] = true;
					nextFreeColorIndex = rndPos;
					break;
				}
			}
			return nextFreeColorIndex;
		}


/////// Farbe wieder frei geben ////////////////////////////////////////////////
		private function setFreeColorIndex(p_arrayIndex : int) : void 
		{
//			trace("GUI -> setFreeColor() ...");
			Globals.countryColorArray[p_arrayIndex][0] = false;
		}
		

		
		
		
		


////////////////////////////////////////////////////////////////////////////////
/////// BOOKMARKS //////////////////////////////////////////////////////////////
		
		private function createBookmarkHandler(evt : CustomEvent) : void 
		{
//			trace("GUI -> createBookmark() ...");
			/*
			 * Wenn das Land noch aktiv ist, Bookmark erstellen
			 */
			if(_activeCountryPanelArray[evt.data[8]] is CountryPanel)
			{
				var newBookmark : Bookmark = new Bookmark(evt.data[0], evt.data[1], evt.data[7]);
				newBookmark.x    		= evt.data[2];
				newBookmark.y   		= evt.data[3];
				newBookmark.scaleX    	= evt.data[4];
				newBookmark.scaleY		= evt.data[5];
				newBookmark.rotation 	= evt.data[6] + _activeCountryPanelArray[evt.data[8]].rotation;
				newBookmark.addEventListener(Bookmark.START_FADING_OUT, bookmarkStartFadingOutHandler);
				newBookmark.addEventListener(TouchEvent.MOUSE_DOWN, bookmarkOnMouseDownHandler);
				_bookmarkArray[evt.data[8]][_bookmarkArray[evt.data[8]].length] = newBookmark;
				_bookmarkContainer.addChild(newBookmark);
			}
			
		}

		private function bookmarkStartFadingOutHandler(evt : Event) : void 
		{
//			trace("GUI -> bookmarkOnStartFadingOut");
			var fadingOutBookmark : Bookmark = evt.currentTarget as Bookmark;
			bookmarkStartFadingOut(fadingOutBookmark);
		}
		
		private function bookmarkStartFadingOut(p_bookmarkToFadeOut : Bookmark) : void 
		{
//			trace("GUI -> bookmarkOnStartFadingOut");
			/*
			 * Bookmark darf auf keine Blobs mehr hören!
			 */
			p_bookmarkToFadeOut.removeEventListener(Bookmark.START_FADING_OUT, bookmarkStartFadingOutHandler);
			p_bookmarkToFadeOut.removeEventListener(TouchEvent.MOUSE_DOWN, p_bookmarkToFadeOut.downEvent);
			p_bookmarkToFadeOut.removeEventListener(Event.ENTER_FRAME, p_bookmarkToFadeOut.update);
			TweenLite.to(p_bookmarkToFadeOut, 2, {alpha: 0, ease:Strong.easeOut, onComplete: onBookmarkFadedOut, onCompleteParams: [p_bookmarkToFadeOut]});
		}

		private function onBookmarkFadedOut(p_fadedOutBookmark : Bookmark) : void 
		{
//			trace("GUI -> onBookmarkFadedOut() ...");
			/*
			 * Geloeschtes Bookmark im Array suchen und aus dem Array entfernen
			 */
			for(var i:int = 0; i < _bookmarkArray.length; i++)
			{
				for(var j:int = 0; j < _bookmarkArray[i].length; j++)
				{	
					if(_bookmarkArray[i][j] == p_fadedOutBookmark)
					{
						/*
						 * Bookmark existiert noch (countryFiducial noch nicht entfernt)
						 */
//						trace("GUI -> onBookmarkFadedOut() ::: Bookmark entfernt");
						_bookmarkArray[i].splice(j, 1);
						_bookmarkContainer.removeChild(p_fadedOutBookmark);
						break;
					}
				}
			}
		}

	
		private function bookmarkOnMouseDownHandler(evt : TouchEvent) : void 
		{
//			trace("GUI -> bookmarkOnMouseDownHandler() ...");
			var fadingOutBookmark : Bookmark = evt.currentTarget as Bookmark;
			fadingOutBookmark.addEventListener(RotatableScalable.FINGER_UP, bookmarkFingerUpHandler);
			fadingOutBookmark.stopFadingOutTimer();
		}
//		
		private function bookmarkFingerUpHandler(evt : Event) : void 
		{
//			trace("GUI -> bookmarkFingerUpHandler() ...");
			var touchedBookmark : Bookmark = evt.currentTarget as Bookmark;
			touchedBookmark.removeEventListener(RotatableScalable.FINGER_UP, bookmarkFingerUpHandler);
			touchedBookmark.startFadingOutTimer();
			/*
			 * Erstelltes Bookmark hinter Layers und _interface auf die Buhne legen, 
			 * aber als oberstes im Bookmarkarray, weil das neueste ist.
			 */
//			setChildIndex(touchedBookmark, (_bookmarkArray.length+1));
		}








		


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
	}
}
